home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gsstruct.h < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-29  |  30.2 KB  |  648 lines
  1. /* Copyright (C) 1993, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gsstruct.h */
  20. /* Definitions for Ghostscript modules that define allocatable structures */
  21. /* Requires gstypes.h */
  22.  
  23. #ifndef gsstruct_INCLUDED
  24. #  define gsstruct_INCLUDED
  25.  
  26. /*
  27.  * Ghostscript structures are defined with names of the form (gs_)xxx_s,
  28.  * with a corresponding typedef of the form (gs_)xxx or (gs_)xxx_t.
  29.  * By extension, the structure descriptor is named st_[gs_]xxx.
  30.  * (Note that the descriptor name may omit the gs_ even if the type has it.)
  31.  * Structure descriptors are always allocated statically and are
  32.  * always const; they may be either public or private.
  33.  *
  34.  * In order to ensure that there is a descriptor for each structure type,
  35.  * we require, by convention, that the following always appear together
  36.  * if the structure is defined in a .h file:
  37.  *    - The definition of the structure xxx_s;
  38.  *    - If the descriptor is public, an extern_st(st_xxx);
  39.  *    - The definition of a macro public_st_xxx() or private_st_xxx()
  40.  *    that creates the actual descriptor.
  41.  * This convention makes the descriptor visible (if public) to any module
  42.  * that can see the structure definition.  This is more liberal than
  43.  * we would like, but it is a reasonable compromise between restricting
  44.  * visibility and keeping all the definitional elements of a structure
  45.  * together.  We require that there be no other externs for (public)
  46.  * structure descriptors; if the definer of a structure wants to make
  47.  * available the ability to create an instance but does not want to
  48.  * expose the structure definition, it must export a creator procedure.
  49.  *
  50.  * Because of bugs in some compilers' bookkeeping for undefined structure
  51.  * types, any file that uses extern_st must include gsstruct.h.
  52.  * (If it weren't for these bugs, the definition of extern_st could
  53.  * go in gsmemory.h.)
  54.  */
  55. #define extern_st(st) extern const gs_memory_struct_type_t st
  56. /*
  57.  * If the structure is defined in a .c file, we require that the following
  58.  * appear together:
  59.  *    - The definition of the structure xxx_s;
  60.  *    - The gs_private_st_xxx macro that creates the descriptor.
  61.  * Note that we only allow this if the structure is completely private
  62.  * to a single file.  Again, the file must export a creator procedure
  63.  * if it wants external clients to be able to create instances.
  64.  *
  65.  * Some structures are embedded inside others.  In order to be able to
  66.  * construct the composite pointer enumeration procedures, for such
  67.  * structures we must define not only the st_xxx descriptor, but also
  68.  * a st_xxx_max_ptrs constant that gives the maximum number of pointers
  69.  * the enumeration procedure will return.  This is an unfortunate consequence
  70.  * of the method we have chosen for implementing pointer enumeration.
  71.  *
  72.  * Some structures may exist as elements of homogenous arrays.
  73.  * In order to be able to enumerate and relocate such arrays, we adopt
  74.  * the convention that the structure representing an element must be
  75.  * distinguished from the structure per se, and the name of the element
  76.  * structure always ends with "_element".  Element structures cannot be
  77.  * embedded in other structures.
  78.  *
  79.  * Note that the definition of the xxx_s structure may be separate from
  80.  * the typedef for the type xxx(_t).  This still allows us to have full
  81.  * structure type abstraction.
  82.  *
  83.  * Descriptor definitions are not required for structures to which
  84.  * no traceable pointers from garbage-collectable space will ever exist.
  85.  * For example, the struct that defines structure types themselves does not
  86.  * require a descriptor.
  87.  */
  88.  
  89. /* An opaque type for an object header. */
  90. #ifndef obj_header_DEFINED
  91. #  define obj_header_DEFINED
  92. typedef struct obj_header_s obj_header_t;
  93. #endif
  94.  
  95. /*
  96.  * A descriptor for an object (structure) type.
  97.  */
  98. typedef struct struct_shared_procs_s struct_shared_procs_t;
  99. struct gs_memory_struct_type_s {
  100.     uint ssize;
  101.     struct_name_t sname;
  102.  
  103.     /* ------ Procedures shared among many structure types. ------ */
  104.     /* Note that this pointer is usually 0. */
  105.  
  106.     const struct_shared_procs_t _ds *shared;
  107.  
  108.     /* ------ Procedures specific to this structure type. ------ */
  109.     /* Note that these procedures may be 0. */
  110.  
  111.         /* Clear the marks of a structure. */
  112.  
  113. #define struct_proc_clear_marks(proc)\
  114.   void proc(P2(void /*obj_header_t*/ *pre, uint size))
  115.     struct_proc_clear_marks((*clear_marks));
  116.  
  117.         /* Enumerate the pointers in a structure. */
  118.  
  119. #define struct_proc_enum_ptrs(proc)\
  120.   gs_ptr_type_t proc(P4(void /*obj_header_t*/ *ptr, uint size, uint index,\
  121.     const void **pep))
  122.     struct_proc_enum_ptrs((*enum_ptrs));
  123.  
  124.         /* Relocate all the pointers in this structure. */
  125.  
  126. #define struct_proc_reloc_ptrs(proc)\
  127.   void proc(P3(void /*obj_header_t*/ *ptr, uint size, gc_state_t *gcst))
  128.     struct_proc_reloc_ptrs((*reloc_ptrs));
  129.  
  130.         /*
  131.          * Finalize this structure just before freeing it.
  132.          * Finalization procedures must not allocate or resize
  133.          * any objects in any space managed by the allocator,
  134.          * and must not assume that any objects in such spaces
  135.          * referenced by this structure still exist.  However,
  136.          * finalization procedures may free such objects, and
  137.          * may allocate, free, and reference objects allocated
  138.          * in other ways, such as objects allocated with malloc
  139.          * by libraries.
  140.          */
  141.  
  142. #define struct_proc_finalize(proc)\
  143.   void proc(P1(void /*obj_header_t*/ *ptr))
  144.     struct_proc_finalize((*finalize));
  145.  
  146. };
  147. #define struct_type_name_string(pstype) ((const char *)((pstype)->sname))
  148. /* Default pointer processing */
  149. struct_proc_enum_ptrs(gs_no_struct_enum_ptrs);
  150. struct_proc_reloc_ptrs(gs_no_struct_reloc_ptrs);
  151. /* Standard relocation procedures */
  152. ptr_proc_reloc(gs_reloc_struct_ptr, void /*obj_header_t*/);
  153. void gs_reloc_string(P2(gs_string *, gc_state_t *));
  154. void gs_reloc_const_string(P2(gs_const_string *, gc_state_t *));
  155.  
  156. /* Define a 'type' descriptor for free blocks. */
  157. extern_st(st_free);
  158.  
  159. /* Define a type descriptor for byte objects. */
  160. extern_st(st_bytes);
  161.  
  162. /* ================ Macros for defining structure types ================ */
  163.  
  164. #define public_st public const gs_memory_struct_type_t
  165. #define private_st private const gs_memory_struct_type_t
  166.  
  167. /* -------------- Simple structures (no internal pointers). -------------- */
  168.  
  169. #define gs__st_simple(scope_st, stname, stype, sname)\
  170.   scope_st stname = { sizeof(stype), sname, 0, 0, 0, 0, 0 }
  171. #define gs_public_st_simple(stname, stype, sname)\
  172.   gs__st_simple(public_st, stname, stype, sname)
  173. #define gs_private_st_simple(stname, stype, sname)\
  174.   gs__st_simple(private_st, stname, stype, sname)
  175.  
  176. /* ---------------- Structures with explicit procedures. ---------------- */
  177.  
  178.     /* Complex structures with their own clear_marks, */
  179.     /* enum, reloc, and finalize procedures. */
  180.  
  181. #define gs__st_complex_only(scope_st, stname, stype, sname, pclear, penum, preloc, pfinal)\
  182.   scope_st stname = { sizeof(stype), sname, 0, pclear, penum, preloc, pfinal }
  183. #define gs_public_st_complex_only(stname, stype, sname, pclear, penum, preloc, pfinal)\
  184.   gs__st_complex_only(public_st, stname, stype, sname, pclear, penum, preloc, pfinal)
  185. #define gs_private_st_complex_only(stname, stype, sname, pclear, penum, preloc, pfinal)\
  186.   gs__st_complex_only(private_st, stname, stype, sname, pclear, penum, preloc, pfinal)
  187.  
  188. #define gs__st_complex(scope_st, stname, stype, sname, pclear, penum, preloc, pfinal)\
  189.   private struct_proc_clear_marks(pclear);\
  190.   private struct_proc_enum_ptrs(penum);\
  191.   private struct_proc_reloc_ptrs(preloc);\
  192.   private struct_proc_finalize(pfinal);\
  193.   gs__st_complex_only(scope_st, stname, stype, sname, pclear, penum, preloc, pfinal)
  194. #define gs_public_st_complex(stname, stype, sname, pclear, penum, preloc, pfinal)\
  195.   gs__st_complex(public_st, stname, stype, sname, pclear, penum, preloc, pfinal)
  196. #define gs_private_st_complex(stname, stype, sname, pclear, penum, preloc, pfinal)\
  197.   gs__st_complex(private_st, stname, stype, sname, pclear, penum, preloc, pfinal)
  198.  
  199.     /* Composite structures with their own enum and reloc procedures. */
  200.  
  201. #define gs__st_composite(scope_st, stname, stype, sname, penum, preloc)\
  202.   private struct_proc_enum_ptrs(penum);\
  203.   private struct_proc_reloc_ptrs(preloc);\
  204.   gs__st_complex_only(scope_st, stname, stype, sname, 0, penum, preloc, 0)
  205. #define gs_public_st_composite(stname, stype, sname, penum, preloc)\
  206.   gs__st_composite(public_st, stname, stype, sname, penum, preloc)
  207. #define gs_private_st_composite(stname, stype, sname, penum, preloc)\
  208.   gs__st_composite(private_st, stname, stype, sname, penum, preloc)
  209.  
  210.     /* Composite structures with finalization. */
  211.  
  212. #define gs__st_composite_final(scope_st, stname, stype, sname, penum, preloc, pfinal)\
  213.   private struct_proc_enum_ptrs(penum);\
  214.   private struct_proc_reloc_ptrs(preloc);\
  215.   private struct_proc_finalize(pfinal);\
  216.   gs__st_complex_only(scope_st, stname, stype, sname, 0, penum, preloc, pfinal)
  217. #define gs_public_st_composite_final(stname, stype, sname, penum, preloc, pfinal)\
  218.   gs__st_composite_final(public_st, stname, stype, sname, penum, preloc, pfinal)
  219. #define gs_private_st_composite_final(stname, stype, sname, penum, preloc, pfinal)\
  220.   gs__st_composite_final(private_st, stname, stype, sname, penum, preloc, pfinal)
  221.  
  222.     /* Composite structures with enum and reloc procedures */
  223.     /* already declared. */
  224.  
  225. #define gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)\
  226.   gs__st_complex_only(scope_st, stname, stype, sname, 0, penum, preloc, 0)
  227. #define gs_public_st_composite_only(stname, stype, sname, penum, preloc)\
  228.   gs__st_composite_only(public_st, stname, stype, sname, penum, preloc)
  229. #define gs_private_st_composite_only(stname, stype, sname, penum, preloc)\
  230.   gs__st_composite_only(private_st, stname, stype, sname, penum, preloc)
  231.  
  232. /* ---------------- Special kinds of structures ---------------- */
  233.  
  234.     /* Element structures, for use in arrays of structures. */
  235.     /* Note that these require that the underlying structure's */
  236.     /* enum_ptrs procedure always return the same number of pointers. */
  237.  
  238. #define gs__st_element(scope_st, stname, stype, sname, penum, preloc, basest)\
  239.   private ENUM_PTRS_BEGIN_PROC(penum) {\
  240.     uint count = size / (uint)sizeof(stype);\
  241.     if ( count == 0 ) return 0;\
  242.     return (*basest.enum_ptrs)((char *)vptr + (index % count) * sizeof(stype),\
  243.       sizeof(stype), index / count, pep);\
  244.   } ENUM_PTRS_END_PROC\
  245.   private RELOC_PTRS_BEGIN(preloc) {\
  246.     uint count = size / (uint)sizeof(stype);\
  247.     for ( ; count; count--, vptr = (char *)vptr + sizeof(stype) )\
  248.       (*basest.reloc_ptrs)(vptr, sizeof(stype), gcst);\
  249.   } RELOC_PTRS_END\
  250.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  251. #define gs_public_st_element(stname, stype, sname, penum, preloc, basest)\
  252.   gs__st_element(public_st, stname, stype, sname, penum, preloc, basest)
  253. #define gs_private_st_element(stname, stype, sname, penum, preloc, basest)\
  254.   gs__st_element(private_st, stname, stype, sname, penum, preloc, basest)
  255.  
  256.     /* A "structure" just consisting of a pointer. */
  257.     /* Note that in this case only, stype is a pointer type. */
  258.  
  259. #define gs__st_ptr(scope_st, stname, stype, sname, penum, preloc)\
  260.   private ENUM_PTRS_BEGIN(penum) return 0;\
  261.     case 0: *pep = (const void *)*(stype *)vptr; return ptr_struct_type;\
  262.   ENUM_PTRS_END\
  263.   private RELOC_PTRS_BEGIN(preloc) ;\
  264.     *(stype *)vptr = gs_reloc_struct_ptr((const void *)*(stype *)vptr, gcst);\
  265.   RELOC_PTRS_END\
  266.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  267. #define gs_public_st_ptr(stname, stype, sname, penum, preloc)\
  268.   gs__st_ptr(public_st, stname, stype, sname, penum, preloc)
  269. #define gs_private_st_ptr(stname, stype, sname, penum, preloc)\
  270.   gs__st_ptr(private_st, stname, stype, sname, penum, preloc)
  271.  
  272. /* ---------------- Ordinary structures ---------------- */
  273.  
  274. /*
  275.  * The simplest kind of composite structure is one with a fixed set of
  276.  * pointers, each of which points to a struct.  We provide macros for
  277.  * defining this kind of structure conveniently, either all at once in
  278.  * the structure definition macro, or using the following template:
  279.  
  280. ENUM_PTRS_BEGIN(xxx_enum_ptrs) return 0;
  281.     ... ENUM_PTR(i, xxx, elt); ...
  282. ENUM_PTRS_END
  283. RELOC_PTRS_BEGIN(xxx_reloc_ptrs) ;
  284.     ... RELOC_PTR(xxx, elt) ...
  285. RELOC_PTRS_END
  286.  
  287.  */
  288. /*
  289.  * We have to pull the 'private' outside the ENUM_PTRS_BEGIN and
  290.  * RELOC_PTRS_BEGIN macros because of a bug in the Borland C++ preprocessor.
  291.  * We also have to make sure there is more on the line after these
  292.  * macros, so as not to confuse ansi2knr.
  293.  */
  294. #ifdef __PROTOTYPES__
  295. #  define ENUM_PTRS_BEGIN_PROC(proc)\
  296.     gs_ptr_type_t proc(void *vptr, uint size, uint index, const void **pep)
  297. #else
  298. #  define ENUM_PTRS_BEGIN_PROC(proc)\
  299.     gs_ptr_type_t proc(vptr, size, index, pep) void *vptr; uint size; uint index; const void **pep;
  300. #endif
  301. #define ENUM_PTRS_BEGIN(proc)\
  302.   ENUM_PTRS_BEGIN_PROC(proc) { switch ( index ) { default:
  303. #define ENUM_PTR(i, typ, elt)\
  304.   case i: ENUM_RETURN_PTR(typ, elt)
  305. #define ENUM_RETURN_PTR(typ, elt)\
  306.   ENUM_RETURN(((typ *)vptr)->elt)
  307. #define ENUM_RETURN(ptr)\
  308.   do { *pep = (const void *)(ptr); return ptr_struct_type; } while (0)
  309. #define ENUM_STRING_PTR(i, typ, elt)\
  310.   case i: ENUM_RETURN_STRING_PTR(typ, elt)
  311. #define ENUM_RETURN_STRING_PTR(typ, elt)\
  312.   do { *pep = (const void *)&((typ *)vptr)->elt; return ptr_string_type; } while (0)
  313. #define ENUM_CONST_STRING_PTR(i, typ, elt)\
  314.   case i: ENUM_RETURN_CONST_STRING_PTR(typ, elt)
  315. #define ENUM_RETURN_CONST_STRING_PTR(typ, elt)\
  316.   do { *pep = (const void *)&((typ *)vptr)->elt; return ptr_const_string_type; } while (0)
  317. #define ENUM_PTRS_END\
  318.   } /* mustn't fall through! */ ENUM_PTRS_END_PROC }
  319. #define ENUM_PTRS_END_PROC /* */
  320. #ifdef __PROTOTYPES__
  321. #  define RELOC_PTRS_BEGIN(proc)\
  322.     void proc(void *vptr, uint size, gc_state_t *gcst) {
  323. #else
  324. #  define RELOC_PTRS_BEGIN(proc)\
  325.     void proc(vptr, size, gcst) void *vptr; uint size; gc_state_t *gcst; {
  326. #endif
  327. #define RELOC_PTR(typ, elt)\
  328.   ((typ *)vptr)->elt =\
  329.     gs_reloc_struct_ptr((const void *)((const typ *)vptr)->elt, gcst)
  330. /* Relocate a pointer that points to a known offset within an object. */
  331. /* OFFSET is for byte offsets, TYPED_OFFSET is for element offsets. */
  332. #define RELOC_OFFSET_PTR(typ, elt, offset)\
  333.   ((typ *)vptr)->elt = (void *)\
  334.     ((char *)gs_reloc_struct_ptr((char *)((typ *)vptr)->elt - (offset), gcst) +\
  335.      (offset))
  336. #define RELOC_TYPED_OFFSET_PTR(typ, elt, offset)\
  337.   (((typ *)vptr)->elt = (void *)\
  338.     gs_reloc_struct_ptr(((typ *)vptr)->elt - (offset), gcst),\
  339.    ((typ *)vptr)->elt += (offset))
  340. #define RELOC_STRING_PTR(typ, elt)\
  341.   gs_reloc_string(&((typ *)vptr)->elt, gcst)
  342. #define RELOC_CONST_STRING_PTR(typ, elt)\
  343.   gs_reloc_const_string(&((typ *)vptr)->elt, gcst)
  344. #define RELOC_PTRS_END\
  345.   }
  346.  
  347. /*
  348.  * Boilerplate for clear_marks procedures.
  349.  */
  350. #ifdef __PROTOTYPES__
  351. #  define CLEAR_MARKS_PROC(proc)\
  352.     void proc(void *vptr, uint size)
  353. #else
  354. #  define CLEAR_MARKS_PROC(proc)\
  355.     void proc(vptr, size) void *vptr; uint size;
  356. #endif
  357.  
  358. /* ---------------- Structures with a fixed set of pointers ---------------- */
  359.  
  360.     /* Structures with 1 pointer. */
  361.  
  362. #define gs__st_ptrs1(scope_st, stname, stype, sname, penum, preloc, e1)\
  363.   private ENUM_PTRS_BEGIN(penum) return 0;\
  364.     ENUM_PTR(0,stype,e1);\
  365.   ENUM_PTRS_END\
  366.   private RELOC_PTRS_BEGIN(preloc) ;\
  367.     RELOC_PTR(stype,e1);\
  368.   RELOC_PTRS_END\
  369.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  370. #define gs_public_st_ptrs1(stname, stype, sname, penum, preloc, e1)\
  371.   gs__st_ptrs1(public_st, stname, stype, sname, penum, preloc, e1)
  372. #define gs_private_st_ptrs1(stname, stype, sname, penum, preloc, e1)\
  373.   gs__st_ptrs1(private_st, stname, stype, sname, penum, preloc, e1)
  374.  
  375.     /* Structures with 2 pointers. */
  376.  
  377. #define gs__st_ptrs2(scope_st, stname, stype, sname, penum, preloc, e1, e2)\
  378.   private ENUM_PTRS_BEGIN(penum) return 0;\
  379.     ENUM_PTR(0,stype,e1); ENUM_PTR(1,stype,e2);\
  380.   ENUM_PTRS_END\
  381.   private RELOC_PTRS_BEGIN(preloc) ;\
  382.     RELOC_PTR(stype,e1); RELOC_PTR(stype,e2);\
  383.   RELOC_PTRS_END\
  384.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  385. #define gs_public_st_ptrs2(stname, stype, sname, penum, preloc, e1, e2)\
  386.   gs__st_ptrs2(public_st, stname, stype, sname, penum, preloc, e1, e2)
  387. #define gs_private_st_ptrs2(stname, stype, sname, penum, preloc, e1, e2)\
  388.   gs__st_ptrs2(private_st, stname, stype, sname, penum, preloc, e1, e2)
  389.  
  390.     /* Structures with 3 pointers. */
  391.  
  392. #define gs__st_ptrs3(scope_st, stname, stype, sname, penum, preloc, e1, e2, e3)\
  393.   private ENUM_PTRS_BEGIN(penum) return 0;\
  394.     ENUM_PTR(0,stype,e1); ENUM_PTR(1,stype,e2); ENUM_PTR(2,stype,e3);\
  395.   ENUM_PTRS_END\
  396.   private RELOC_PTRS_BEGIN(preloc) ;\
  397.     RELOC_PTR(stype,e1); RELOC_PTR(stype,e2); RELOC_PTR(stype,e3);\
  398.   RELOC_PTRS_END\
  399.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  400. #define gs_public_st_ptrs3(stname, stype, sname, penum, preloc, e1, e2, e3)\
  401.   gs__st_ptrs3(public_st, stname, stype, sname, penum, preloc, e1, e2, e3)
  402. #define gs_private_st_ptrs3(stname, stype, sname, penum, preloc, e1, e2, e3)\
  403.   gs__st_ptrs3(private_st, stname, stype, sname, penum, preloc, e1, e2, e3)
  404.  
  405.     /* Structures with 4 pointers. */
  406.  
  407. #define gs__st_ptrs4(scope_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4)\
  408.   private ENUM_PTRS_BEGIN(penum) return 0;\
  409.     ENUM_PTR(0,stype,e1); ENUM_PTR(1,stype,e2); ENUM_PTR(2,stype,e3);\
  410.     ENUM_PTR(3,stype,e4);\
  411.   ENUM_PTRS_END\
  412.   private RELOC_PTRS_BEGIN(preloc) ;\
  413.     RELOC_PTR(stype,e1); RELOC_PTR(stype,e2); RELOC_PTR(stype,e3);\
  414.     RELOC_PTR(stype,e4);\
  415.   RELOC_PTRS_END\
  416.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  417. #define gs_public_st_ptrs4(stname, stype, sname, penum, preloc, e1, e2, e3, e4)\
  418.   gs__st_ptrs4(public_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4)
  419. #define gs_private_st_ptrs4(stname, stype, sname, penum, preloc, e1, e2, e3, e4)\
  420.   gs__st_ptrs4(private_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4)
  421.  
  422.     /* Structures with 5 pointers. */
  423.  
  424. #define gs__st_ptrs5(scope_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5)\
  425.   private ENUM_PTRS_BEGIN(penum) return 0;\
  426.     ENUM_PTR(0,stype,e1); ENUM_PTR(1,stype,e2); ENUM_PTR(2,stype,e3);\
  427.     ENUM_PTR(3,stype,e4); ENUM_PTR(4,stype,e5);\
  428.   ENUM_PTRS_END\
  429.   private RELOC_PTRS_BEGIN(preloc) ;\
  430.     RELOC_PTR(stype,e1); RELOC_PTR(stype,e2); RELOC_PTR(stype,e3);\
  431.     RELOC_PTR(stype,e4); RELOC_PTR(stype,e5);\
  432.   RELOC_PTRS_END\
  433.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  434. #define gs_public_st_ptrs5(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5)\
  435.   gs__st_ptrs5(public_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5)
  436. #define gs_private_st_ptrs5(stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5)\
  437.   gs__st_ptrs5(private_st, stname, stype, sname, penum, preloc, e1, e2, e3, e4, e5)
  438.  
  439. /* ---------------- Suffix subclasses ---------------- */
  440.  
  441. /*
  442.  * Boilerplate for suffix subclasses.  Special subclasses constructed
  443.  * 'by hand' may use this also.
  444.  */
  445. #define ENUM_PREFIX(supst, n)\
  446.   return (*supst.enum_ptrs)(vptr,size,index-(n),pep)
  447. #define RELOC_PREFIX(supst)\
  448.   (*supst.reloc_ptrs)(vptr,size,gcst)
  449.  
  450.     /* Suffix subclasses with no additional pointers. */
  451.  
  452. #define gs__st_suffix_add0(scope_st, stname, stype, sname, penum, preloc, supstname)\
  453.   private ENUM_PTRS_BEGIN_PROC(penum) {\
  454.     return (*supstname.enum_ptrs)(vptr, size, index, pep);\
  455.   } ENUM_PTRS_END_PROC\
  456.   private RELOC_PTRS_BEGIN(preloc) {\
  457.     (*supstname.reloc_ptrs)(vptr, size, gcst);\
  458.   } RELOC_PTRS_END\
  459.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  460. #define gs_public_st_suffix_add0(stname, stype, sname, penum, preloc, supstname)\
  461.   gs__st_suffix_add0(public_st, stname, stype, sname, penum, preloc, supstname)
  462. #define gs_private_st_suffix_add0(stname, stype, sname, penum, preloc, supstname)\
  463.   gs__st_suffix_add0(private_st, stname, stype, sname, penum, preloc, supstname)
  464.  
  465.     /* Suffix subclasses with no additional pointers and finalization. */
  466.     /* This is a hack -- subclasses should inherit finalization, */
  467.     /* but that would require a superclass pointer in the descriptor, */
  468.     /* which would perturb things too much right now. */
  469.  
  470. #define gs__st_suffix_add0_final(scope_st, stname, stype, sname, penum, preloc, pfinal, supstname)\
  471.   private ENUM_PTRS_BEGIN_PROC(penum) {\
  472.     return (*supstname.enum_ptrs)(vptr, size, index, pep);\
  473.   } ENUM_PTRS_END_PROC\
  474.   private RELOC_PTRS_BEGIN(preloc) {\
  475.     (*supstname.reloc_ptrs)(vptr, size, gcst);\
  476.   } RELOC_PTRS_END\
  477.   gs__st_complex_only(scope_st, stname, stype, sname, 0, penum, preloc, pfinal)
  478. #define gs_public_st_suffix_add0_final(stname, stype, sname, penum, preloc, pfinal, supstname)\
  479.   gs__st_suffix_add0_final(public_st, stname, stype, sname, penum, preloc, pfinal, supstname)
  480. #define gs_private_st_suffix_add0_final(stname, stype, sname, penum, preloc, pfinal, supstname)\
  481.   gs__st_suffix_add0_final(private_st, stname, stype, sname, penum, preloc, pfinal, supstname)
  482.  
  483.     /* Suffix subclasses with 1 additional pointer. */
  484.  
  485. #define gs__st_suffix_add1(scope_st, stname, stype, sname, penum, preloc, supstname, e1)\
  486.   private ENUM_PTRS_BEGIN(penum) ENUM_PREFIX(supstname,1);\
  487.     ENUM_PTR(0,stype,e1);\
  488.   ENUM_PTRS_END\
  489.   private RELOC_PTRS_BEGIN(preloc) RELOC_PREFIX(supstname);\
  490.     RELOC_PTR(stype,e1);\
  491.   RELOC_PTRS_END\
  492.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  493. #define gs_public_st_suffix_add1(stname, stype, sname, penum, preloc, supstname, e1)\
  494.   gs__st_suffix_add1(public_st, stname, stype, sname, penum, preloc, supstname, e1)
  495. #define gs_private_st_suffix_add1(stname, stype, sname, penum, preloc, supstname, e1)\
  496.   gs__st_suffix_add1(private_st, stname, stype, sname, penum, preloc, supstname, e1)
  497.  
  498.     /* Suffix subclasses with 1 additional pointer and finalization. */
  499.     /* See above regarding finalization and subclasses. */
  500.  
  501. #define gs__st_suffix_add1_final(scope_st, stname, stype, sname, penum, preloc, pfinal, supstname, e1)\
  502.   private ENUM_PTRS_BEGIN(penum) ENUM_PREFIX(supstname,1);\
  503.     ENUM_PTR(0,stype,e1);\
  504.   ENUM_PTRS_END\
  505.   private RELOC_PTRS_BEGIN(preloc) RELOC_PREFIX(supstname);\
  506.     RELOC_PTR(stype,e1);\
  507.   RELOC_PTRS_END\
  508.   gs__st_complex_only(scope_st, stname, stype, sname, 0, penum, preloc, pfinal)
  509. #define gs_public_st_suffix_add1_final(stname, stype, sname, penum, preloc, pfinal, supstname, e1)\
  510.   gs__st_suffix_add1_final(public_st, stname, stype, sname, penum, preloc, pfinal, supstname, e1)
  511. #define gs_private_st_suffix_add1_final(stname, stype, sname, penum, preloc, pfinal, supstname, e1)\
  512.   gs__st_suffix_add1_final(private_st, stname, stype, sname, penum, preloc, pfinal, supstname, e1)
  513.  
  514.     /* Suffix subclasses with 2 additional pointers. */
  515.  
  516. #define gs__st_suffix_add2(scope_st, stname, stype, sname, penum, preloc, supstname, e1, e2)\
  517.   private ENUM_PTRS_BEGIN(penum) ENUM_PREFIX(supstname,2);\
  518.     ENUM_PTR(0,stype,e1); ENUM_PTR(1,stype,e2);\
  519.   ENUM_PTRS_END\
  520.   private RELOC_PTRS_BEGIN(preloc) RELOC_PREFIX(supstname);\
  521.     RELOC_PTR(stype,e1); RELOC_PTR(stype,e2);\
  522.   RELOC_PTRS_END\
  523.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  524. #define gs_public_st_suffix_add2(stname, stype, sname, penum, preloc, supstname, e1, e2)\
  525.   gs__st_suffix_add2(public_st, stname, stype, sname, penum, preloc, supstname, e1, e2)
  526. #define gs_private_st_suffix_add2(stname, stype, sname, penum, preloc, supstname, e1, e2)\
  527.   gs__st_suffix_add2(private_st, stname, stype, sname, penum, preloc, supstname, e1, e2)
  528.  
  529.     /* Suffix subclasses with 2 additional pointers and finalization. */
  530.     /* See above regarding finalization and subclasses. */
  531.  
  532. #define gs__st_suffix_add2_final(scope_st, stname, stype, sname, penum, preloc, pfinal, supstname, e1, e2)\
  533.   private ENUM_PTRS_BEGIN(penum) ENUM_PREFIX(supstname,2);\
  534.     ENUM_PTR(0,stype,e1); ENUM_PTR(1,stype,e2);\
  535.   ENUM_PTRS_END\
  536.   private RELOC_PTRS_BEGIN(preloc) RELOC_PREFIX(supstname);\
  537.     RELOC_PTR(stype,e1); RELOC_PTR(stype,e2);\
  538.   RELOC_PTRS_END\
  539.   gs__st_complex_only(scope_st, stname, stype, sname, 0, penum, preloc, pfinal)
  540. #define gs_public_st_suffix_add2_final(stname, stype, sname, penum, preloc, pfinal, supstname, e1, e2)\
  541.   gs__st_suffix_add2_final(public_st, stname, stype, sname, penum, preloc, pfinal, supstname, e1, e2)
  542. #define gs_private_st_suffix_add2_final(stname, stype, sname, penum, preloc, pfinal, supstname, e1, e2)\
  543.   gs__st_suffix_add2_final(private_st, stname, stype, sname, penum, preloc, pfinal, supstname, e1, e2)
  544.  
  545.     /* Suffix subclasses with 3 additional pointers. */
  546.  
  547. #define gs__st_suffix_add3(scope_st, stname, stype, sname, penum, preloc, supstname, e1, e2, e3)\
  548.   private ENUM_PTRS_BEGIN(penum) ENUM_PREFIX(supstname,3);\
  549.     ENUM_PTR(0,stype,e1); ENUM_PTR(1,stype,e2); ENUM_PTR(2,stype,e3);\
  550.   ENUM_PTRS_END\
  551.   private RELOC_PTRS_BEGIN(preloc) RELOC_PREFIX(supstname);\
  552.     RELOC_PTR(stype,e1); RELOC_PTR(stype,e2); RELOC_PTR(stype,e3);\
  553.   RELOC_PTRS_END\
  554.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  555. #define gs_public_st_suffix_add3(stname, stype, sname, penum, preloc, supstname, e1, e2, e3)\
  556.   gs__st_suffix_add3(public_st, stname, stype, sname, penum, preloc, supstname, e1, e2, e3)
  557. #define gs_private_st_suffix_add3(stname, stype, sname, penum, preloc, supstname, e1, e2, e3)\
  558.   gs__st_suffix_add3(private_st, stname, stype, sname, penum, preloc, supstname, e1, e2, e3)
  559.  
  560.     /* Suffix subclasses with 3 additional pointers and finalization. */
  561.     /* See above regarding finalization and subclasses. */
  562.  
  563. #define gs__st_suffix_add3_final(scope_st, stname, stype, sname, penum, preloc, pfinal, supstname, e1, e2, e3)\
  564.   private ENUM_PTRS_BEGIN(penum) ENUM_PREFIX(supstname,3);\
  565.     ENUM_PTR(0,stype,e1); ENUM_PTR(1,stype,e2); ENUM_PTR(2,stype,e3);\
  566.   ENUM_PTRS_END\
  567.   private RELOC_PTRS_BEGIN(preloc) RELOC_PREFIX(supstname);\
  568.     RELOC_PTR(stype,e1); RELOC_PTR(stype,e2); RELOC_PTR(stype,e3);\
  569.   RELOC_PTRS_END\
  570.   gs__st_complex_only(scope_st, stname, stype, sname, 0, penum, preloc, pfinal)
  571. #define gs_public_st_suffix_add3_final(stname, stype, sname, penum, preloc, pfinal, supstname, e1, e2, e3)\
  572.   gs__st_suffix_add3_final(public_st, stname, stype, sname, penum, preloc, pfinal, supstname, e1, e2, e3)
  573. #define gs_private_st_suffix_add3_final(stname, stype, sname, penum, preloc, pfinal, supstname, e1, e2, e3)\
  574.   gs__st_suffix_add3_final(private_st, stname, stype, sname, penum, preloc, pfinal, supstname, e1, e2, e3)
  575.  
  576.     /* Suffix subclasses with 4 additional pointers. */
  577.  
  578. #define gs__st_suffix_add4(scope_st, stname, stype, sname, penum, preloc, supstname, e1, e2, e3, e4)\
  579.   private ENUM_PTRS_BEGIN(penum) ENUM_PREFIX(supstname,3);\
  580.     ENUM_PTR(0,stype,e1); ENUM_PTR(1,stype,e2); ENUM_PTR(2,stype,e3);\
  581.     ENUM_PTR(3,stype,e4);\
  582.   ENUM_PTRS_END\
  583.   private RELOC_PTRS_BEGIN(preloc) RELOC_PREFIX(supstname);\
  584.     RELOC_PTR(stype,e1); RELOC_PTR(stype,e2); RELOC_PTR(stype,e3);\
  585.     RELOC_PTR(stype,e4);\
  586.   RELOC_PTRS_END\
  587.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  588. #define gs_public_st_suffix_add4(stname, stype, sname, penum, preloc, supstname, e1, e2, e3, e4)\
  589.   gs__st_suffix_add4(public_st, stname, stype, sname, penum, preloc, supstname, e1, e2, e3, e4)
  590. #define gs_private_st_suffix_add4(stname, stype, sname, penum, preloc, supstname, e1, e2, e3, e4)\
  591.   gs__st_suffix_add4(private_st, stname, stype, sname, penum, preloc, supstname, e1, e2, e3, e4)
  592.  
  593. /* ---------------- General subclasses ---------------- */
  594.  
  595. /*
  596.  * Boilerplate for general subclasses.
  597.  */
  598. #define ENUM_SUPER(stype, supst, member, n)\
  599.   return (*supst.enum_ptrs)(&((stype *)vptr)->member, sizeof(((stype *)vptr)->member),\
  600.     index-(n), pep)
  601. #define RELOC_SUPER(stype, supst, member)\
  602.   (*supst.reloc_ptrs)(&((stype *)vptr)->member, sizeof(((stype *)vptr)->member), gcst)
  603.  
  604.     /* General subclasses with no additional pointers. */
  605.  
  606. #define gs__st_ptrs_add0(scope_st, stname, stype, sname, penum, preloc, supstname, member)\
  607.   private ENUM_PTRS_BEGIN(penum) ENUM_SUPER(stype,supstname,member,0);\
  608.   ENUM_PTRS_END\
  609.   private RELOC_PTRS_BEGIN(preloc) RELOC_SUPER(stype,supstname,member);\
  610.   RELOC_PTRS_END\
  611.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  612. #define gs_public_st_ptrs_add0(stname, stype, sname, penum, preloc, supstname, member)\
  613.   gs__st_ptrs_add0(public_st, stname, stype, sname, penum, preloc, supstname, member)
  614. #define gs_private_st_ptrs_add0(stname, stype, sname, penum, preloc, supstname, member)\
  615.   gs__st_ptrs_add0(private_st, stname, stype, sname, penum, preloc, supstname, member)
  616.  
  617.     /* General subclasses with 1 additional pointer. */
  618.  
  619. #define gs__st_ptrs_add1(scope_st, stname, stype, sname, penum, preloc, supstname, member, e1)\
  620.   private ENUM_PTRS_BEGIN(penum) ENUM_SUPER(stype,supstname,member,1);\
  621.     ENUM_PTR(0,stype,e1);\
  622.   ENUM_PTRS_END\
  623.   private RELOC_PTRS_BEGIN(preloc) RELOC_SUPER(stype,supstname,member);\
  624.     RELOC_PTR(stype,e1);\
  625.   RELOC_PTRS_END\
  626.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  627. #define gs_public_st_ptrs_add1(stname, stype, sname, penum, preloc, supstname, member, e1)\
  628.   gs__st_ptrs_add1(public_st, stname, stype, sname, penum, preloc, supstname, member, e1)
  629. #define gs_private_st_ptrs_add1(stname, stype, sname, penum, preloc, supstname, member, e1)\
  630.   gs__st_ptrs_add1(private_st, stname, stype, sname, penum, preloc, supstname, member, e1)
  631.  
  632.     /* General subclasses with 2 additional pointers. */
  633.  
  634. #define gs__st_ptrs_add2(scope_st, stname, stype, sname, penum, preloc, supstname, member, e1, e2)\
  635.   private ENUM_PTRS_BEGIN(penum) ENUM_SUPER(stype,supstname,member,2);\
  636.     ENUM_PTR(0,stype,e1); ENUM_PTR(1,stype,e2);\
  637.   ENUM_PTRS_END\
  638.   private RELOC_PTRS_BEGIN(preloc) RELOC_SUPER(stype,supstname,member);\
  639.     RELOC_PTR(stype,e1); RELOC_PTR(stype,e2);\
  640.   RELOC_PTRS_END\
  641.   gs__st_composite_only(scope_st, stname, stype, sname, penum, preloc)
  642. #define gs_public_st_ptrs_add2(stname, stype, sname, penum, preloc, supstname, member, e1, e2)\
  643.   gs__st_ptrs_add2(public_st, stname, stype, sname, penum, preloc, supstname, member, e1, e2)
  644. #define gs_private_st_ptrs_add2(stname, stype, sname, penum, preloc, supstname, member, e1, e2)\
  645.   gs__st_ptrs_add2(private_st, stname, stype, sname, penum, preloc, supstname, member, e1, e2)
  646.  
  647. #endif                    /* gsstruct_INCLUDED */
  648.